feat(log-viewer): rebuild the timeline hover card, and one swatch for every colour key - #961

…d-tooltip

# Conflicts:
#	log-viewer/src/components/StackedTimeBar.ts

The legend carried its own category-to-theme-key map, duplicating the one
Themes.ts calls the single source of truth, and its own getTheme() call — so it
resolved colours by a path nothing else in the app used.

toTimelineKeys now takes the colour function, and TimelineView passes
categoryPalette(), the same resolver the inspector's rows read. That collapses
the legacy and modern legend branches into one: categoryPalette already maps a
category to its legacy group, so the legend under the legacy chart now names the
same categories as the modern one, with the colours that chart drew and the
per-category self times it never used to show.

The metric list, the used/limit formatting and the byte format lived inside
EventVitals, so the timeline tooltip carried a second hand-written copy that had
already drifted: lower-cased labels, no percentage, and the wrong SOSL row
denominator.

Move them to core/metrics/eventMetrics.ts. usageParts returns the reading as
parts plus the fraction of the limit, so a caller can render it as text or as a
meter; EventVitals' usage() is now a wrapper over it and renders as before.

The legend read the modern categories through the legacy colour map, and Apex and
Callout both map to Method — so it drew two chips in one colour, and named neither
of them what the legacy chart's own key says.

It now folds the categories that share a group and sums their self time, naming the
six groups the chart draws. The fold is stated rather than inverted from
LEGACY_CATEGORY_MAP: the draw order and the non-empty membership are facts a
derivation loses, and inverting it would pull the canvas service — and the window
it reads as it loads — into a pure util.

A chip carries the categories it stands for, so data-category names something a
reader can resolve. Under legacy the label is a group name and matches no category.

A group missing from lana.timeline.colors also left a swatch unpainted, where
setColors leaves the chart on its built-in colour. The legend reads that default too.

The card measured every reading against a governor limit. The hover is for deciding
where to look, so it now measures a branch against the log's own total — 3 of 30,
spelled "of" so it cannot read as a cap. Risk against limits stays with the governor
strip and the Inspector.

frameTooltipCard.ts holds what the card says and in what order, with no DOM, so it
reads in a test without laying a panel out. The renderer keeps the DOM, the timers,
the placement and the query budget.

Rows are three columns: label, reading, and the frame's own figure. A self reading of
zero stays — it is what says the work happened in a descendant. The duration and the
byte readings state no denominator, because the unit follows the value and the pair
would not compare. Six metric rows at most, the rest counted in the footer and ranked
by the branch's share, so the choice holds as the pointer moves. A heap peak is
unranked: it composes by max, so every frame spanning the transaction's peak reports
the root's figure and would outrank every summed metric.

A frame's name is its description block; category, type, namespace and call site read
on one identity line. The row that the hover was for carries the card's emphasis, so
a frame with no duration no longer puts it on the wall clock.

The marker rail derives from MARKER_COLORS instead of restating it, the self reading
is spelled once in eventMetrics, and usageParts drops the fraction nothing consumed
once the card stopped metering.

lineNumber is where the frame was called from in the containing code, not where it
is defined. "Line" reads as the definition, so the inspector now says "Called from".

A line the parser could not resolve still reads as EXTERNAL on its own, matching the
timeline's identity line.

The metric strip reserved a 12px track for a swatch that is now 8px, and stated a
size the token already owns. Both rows read --lana-swatch-size, and the row style
is written once rather than twice.

The swatch painted itself two ways — a --row-hue fallback in :host and a style
written in updated(). No caller leaves the colour out, and --row-hue is only ever
set by a reveal row, which draws no swatch, so the colour property is now the one
mechanism. Its label became a title on an aria-hidden host, naming what the text
beside it already said; the accessible name belongs in light DOM, as the reveal
rows do it.

eventMetrics owned the only import from features/ anywhere in core/, for a constant
that is a governor fact rather than a Database-tab one. SOSL_ROWS_PER_QUERY_LIMIT
moves down; the Database tab re-exports it so its own consumers are unchanged.
StatementType was declared twice inside core/, so the metric list now owns it and
the event bus re-exports.

hasSelf was read only as `=== false`, where absent and true meant the same thing.
It reads as noSelf. EventVitals' timing row spells the self reading through
selfLabel, like every other view.

…ardown

Toggling the timeline between modern and legacy threw `Cannot read properties
of undefined (reading 'push')` from `TexturePoolClass.returnTexture`.

`app.destroy(true, ...)` releases Pixi's global resources, and TexturePool is
one of them. A timeline runs three apps, so the first destroy emptied the pool
the other two still return their text textures to.

One `destroyTimelineApp` now owns the call, so the rule holds for the next app
as well as these three.

The chart takes its height from a flex row that a `lana.timeline.legacy`
toggle re-lays-out around it. Measuring before that settled read 0, and
`init` rejects that outright: "Container must have non-zero dimensions".

Wait for a size first, so the user sees a chart rather than an error about a
container that is fine.

…g changes

The classifier allocates its points once per `processData` and hands back the
same object for every pointer position inside one time segment. Identity
therefore tells a re-position from a new reading.

Sweeping a segment no longer re-parses the panel or upgrades a swatch element
per row, on a mousemove that is not throttled.

Moving `StatementType` and `SOSL_ROWS_PER_QUERY_LIMIT` left three doc blocks
documenting `import` statements.

…rive

`categoryPalette(timeline && {...})` collapses to `null` while no settings have
been pushed, so the previewed theme was dropped and the legend painted the
default palette while the chart drew the chosen one.

The palette now takes the previewed theme as its own argument, which also
removes the spread that was papering over it.

…vive

`data-category` joined on a space, but `Code Unit` is one category that
contains a space, so a consumer splitting the list read two categories.

… part

The rule parts what the frame is from what it measured. It went on the first
group whatever the card held, so on a marker card — which has no identity
line — it parted nothing.

…into

The wait for a size sat in the Lit component, guarding one call while
`FlameChart.init` still threw on zero for every other caller. It was also a
second ResizeObserver on a container the chart already observes, and an
unbounded one: a container that never gained a size hung instead of reporting.

The chart now waits for its own container, bounded by a frame count, so the
fault still surfaces. That covers every zero-size trigger — a hidden tab, a
collapsed panel — not just the settings toggle, and drops the component's
duplicate of the predicate `init` throws on.

The panel was rebuilt from an HTML string, so every segment the pointer crossed
reparsed it and upgraded a swatch custom element per row.

The rows are elements now, held and written into. `selectRows` chooses and
orders the readings, and says nothing about the DOM.

Two files conflicted where this branch had already changed them.

`StackedTimeBar` — our side replaced the `.legend__swatch` span with
`<color-swatch>`, so the rule has no user; kept upstream's added
`.tip__part-value` selector.

`EventVitals` — combined our shared `EVENT_METRICS` and `noSelf` with
upstream's split `sumTotal`/`sumSelf`. The `SOSL_ROWS_PER_QUERY_LIMIT` import
stays dropped: the constant now lives in `core/metrics/eventMetrics.ts`.